set -e
test -L tools/domain_builder/dom0_ops.h
rm tools/domain_builder/dom0_ops.h
+test -L tools/internal/dom0_ops.h
+rm tools/internal/dom0_ops.h
(find -depth -type d -print | xargs -r rmdir 2>/dev/null) || true
exit 0
mkdir -p tools
mkdir -p tools/domain_builder
ln -s ../../xenolinux-2.4.21-pre4-sparse/arch/xeno/drivers/dom0/dom0_ops.h tools/domain_builder/dom0_ops.h
+mkdir -p tools/internal
+ln -s ../../xenolinux-2.4.21-pre4-sparse/arch/xeno/drivers/dom0/dom0_ops.h tools/internal/dom0_ops.h
(find -depth -type d -print | xargs -r rmdir 2>/dev/null) || true
exit 0
3e71afadoAI0VvAGKebLpToVQxUKfQ tools/domain_builder/mynewdom
3e4d0046VHhXwFuG5FK34AVxqd5A_A tools/domain_builder/newdom
3e4d0046IBzDIeaMbQB-e2QB2ahbig tools/domain_builder/vifinit
+3eb781edFwm_pW9FwnQACIe68viLOw tools/domctl/Makefile
+3eb781fcTp_LPQwaot3SSSehkaf4eg tools/domctl/build.xml
+3eb781fcXf-WczEdAhnTpWfbR55jqA tools/domctl/domctl
+3eb781fcabCKRogwxJA3-jJKstw9Vg tools/domctl/domctl.xml
+3eb781fcffCXkrcWLBxUTOfQFa3Saw tools/domctl/src/uk/ac/cam/cl/xeno/domctl/Command.java
+3eb781fcOLcVAcqnZOAikur6sAP0rA tools/domctl/src/uk/ac/cam/cl/xeno/domctl/CommandDestroy.java
+3eb781fcQuQVSKxKtp4fBgPOwx7DDw tools/domctl/src/uk/ac/cam/cl/xeno/domctl/CommandHelp.java
+3eb781fcRYdxK1HbjBX7r7VlO5PS0w tools/domctl/src/uk/ac/cam/cl/xeno/domctl/CommandNew.java
+3eb781fcbp9IAHTl40CoMavY1FNd_g tools/domctl/src/uk/ac/cam/cl/xeno/domctl/CommandStart.java
+3eb781fdRXSsyEre7LxCmPJMpB5BaQ tools/domctl/src/uk/ac/cam/cl/xeno/domctl/CommandStop.java
+3eb781fdX_thm9iHSxQ8vqQ0fL7Ncg tools/domctl/src/uk/ac/cam/cl/xeno/domctl/Defaults.java
+3eb781fdTWJr8RPdfuG20IC0CzYL2A tools/domctl/src/uk/ac/cam/cl/xeno/domctl/InetAddressPattern.java
+3eb781fdA8LFQEYE2fXg1JDB9OceYA tools/domctl/src/uk/ac/cam/cl/xeno/domctl/Main.java
+3eb781fd_CgRvlaIBkJjxUSnuvCuHQ tools/domctl/src/uk/ac/cam/cl/xeno/domctl/Settings.java
+3eb781fdFDS4lap1-3ZVDtbKZfpVZA tools/domctl/src/uk/ac/cam/cl/xeno/domctl/StringPattern.java
+3eb781fdl4lXWYZzmqDDUAYhAThRqQ tools/internal/Makefile
+3eb781fdc539MQQm47rYRCCR3N5i-Q tools/internal/dom0_defs.h
+3eb781fdEYILyFg60YVBsWNqxWFf1g tools/internal/dom0_ops.h
+3eb781fddjylXbsepjppUyIXa5lcaQ tools/internal/hypervisor_defs.h
+3eb781fdKiQbgozBsgs_zzJQ9ubehw tools/internal/mem_defs.h
+3eb781fdgbSkh2O6JQS-65Dz4n0ItQ tools/internal/xi_build.c
+3eb781fdW1SAyiaC4mTsXq_9fRHh-A tools/internal/xi_create.c
+3eb781fdcJ0fF7rWfzAOArW-x4-gwA tools/internal/xi_destroy.c
+3eb781fd8oRfPgH7qTh7xvgmwD6NgA tools/internal/xi_start.c
+3eb781fd0Eo9K1jEFCSAVzO51i_ngg tools/internal/xi_stop.c
+3eb781fd7211MZsLxJSiuy7W4KnJXg tools/internal/xi_vifinit
3ea53c6dz47kAOwpk54f8_zOAQ5ngw tools/vdmanager/build.xml
3eaff785PwN0C3-xhCf_zMCL27JIgQ tools/vdmanager/notes.xml
3ea53c6dE-azH1i1VJmJMp9SHnETkQ tools/vdmanager/src/uk/ac/cam/cl/xeno/vdmanager/Extent.java
rn@wyvis.research.intel-research.net
smh22@boulderdash.cl.cam.ac.uk
smh22@uridium.cl.cam.ac.uk
+tlh20@elite.cl.cam.ac.uk
dom0_op_t dop;
int cmd_fd;
- dop.cmd = DOM0_KILLDOMAIN;
+ dop.cmd = DOM0_DESTROYDOMAIN;
dop.u.killdomain.domain = dom_id;
dop.u.killdomain.force = force;
return 0;
}
- dop.cmd = DOM0_NEWDOMAIN;
+ dop.cmd = DOM0_CREATEDOMAIN;
dop.u.newdomain.memory_kb = req_mem;
+ dop.u.newdomain.name[0] = 0;
write(cmd_fd, &dop, sizeof(dom0_op_t));
close(cmd_fd);
return -1;
}
- dop.cmd = DOM0_STARTDOM;
+ dop.cmd = DOM0_BUILDDOMAIN;
+ memcpy(&dop.u.meminfo, meminfo, sizeof(dom_meminfo_t));
+ write(cmd_fd, &dop, sizeof(dom0_op_t));
+
+ dop.cmd = DOM0_STARTDOMAIN;
memcpy(&dop.u.meminfo, meminfo, sizeof(dom_meminfo_t));
write(cmd_fd, &dop, sizeof(dom0_op_t));
dom0_op_t dop;
int cmd_fd;
- dop.cmd = DOM0_KILLDOMAIN;
+ dop.cmd = DOM0_DESTROYDOMAIN;
dop.u.killdomain.domain = dom_id;
dop.u.killdomain.force = force;
--- /dev/null
+default:
+ ant dist
+
+clean:
+ ant clean
--- /dev/null
+<project name="domctl project" default="compile">
+ <property name="src" location="src"/>
+ <property name="build" location="build"/>
+ <property name="dist" location="dist"/>
+ <property name="lib" location="lib"/>
+
+ <target name="init">
+ <tstamp/>
+ <mkdir dir="${build}"/>
+ </target>
+
+ <target name="compile" depends="init">
+ <javac srcdir="${src}" destdir="${build}" debug="on"/>
+ </target>
+
+ <target name="dist" depends="compile">
+ <jar jarfile="domctl.jar"
+ excludes="*~"
+ basedir="${build}">
+ <fileset dir="${src}" />
+ <fileset dir=".">
+ <include name="build.xml"/>
+ <include name="domctl"/>
+ </fileset>
+ <manifest>
+ <attribute name="Built-By" value="${user.name}"/>
+ <attribute name="Main-Class" value="uk.ac.cam.cl.xeno.domctl.Main"/>
+ <attribute name="Sealed" value="true"/>
+ </manifest>
+ </jar>
+ </target>
+
+ <target name="test" depends="compile">
+ <java fork="true" classname="uk.ac.cam.cl.xeno.domctl.Main">
+ <classpath>
+ <pathelement path="${build}"/>
+ </classpath>
+ </java>
+ </target>
+
+ <target name="clean">
+ <delete dir="${build}"/>
+ <delete dir="${lib}"/>
+ </target>
+</project>
\ No newline at end of file
--- /dev/null
+#!/bin/bash -x
+
+if [ -z "$DEFAULTS_FILE" ] ; then DEFAULTS_FILE=domctl.xml ; fi
+if [ -z "$DEFAULTS_PATH" ] ; then DEFAULTS_PATH=.:/etc ; fi
+if [ -z "$QUERY_DEV" ] ; then QUERY_DEV=eth0 ; fi
+if [ -z "$IFCONFIG" ] ; then IFCONFIG=/sbin/ifconfig ; fi
+if [ -z "$ROUTE" ] ; then ROUTE=/sbin/route ; fi
+if [ -z "$JAVA" ] ; then JAVA=java ; fi
+
+if [ ! -x "$IFCONFIG" ]; then
+ echo Could not find executable $IFCONFIG
+ exit 1
+fi
+
+if [ ! -x "$ROUTE" ]; then
+ echo Could not find executable $ROUTE
+ exit 1
+fi
+
+# Try to determine dom0 network settings to avoid hard-coding
+# particular machines in the defaults file
+LOCAL_IP=$(/sbin/ifconfig $QUERY_DEV | grep 'inet addr' | tr ':' '\t' | awk '{print $3}')
+LOCAL_MASK=$(/sbin/ifconfig $QUERY_DEV | grep 'Mask' | tr ':' '\t' | awk '{print $7}')
+LOCAL_ROUTE=$(/sbin/route -n | grep $QUERY_DEV | grep 'G' | awk '{print $2}')
+
+
+#ARGS="-DTEST -DDEFAULTS_FILE=$DEFAULTS_FILE -DDEFAULTS_PATH=$DEFAULTS_PATH -DLOCAL_IP=$LOCAL_IP -DLOCAL_MASK=$LOCAL_MASK -DLOCAL_ROUTE=$LOCAL_ROUTE"
+ARGS="-DDEFAULTS_FILE=$DEFAULTS_FILE -DDEFAULTS_PATH=$DEFAULTS_PATH -DLOCAL_IP=$LOCAL_IP -DLOCAL_MASK=$LOCAL_MASK -DLOCAL_ROUTE=$LOCAL_ROUTE"
+
+
+$JAVA $ARGS -jar domctl.jar $*
--- /dev/null
+<?xml version="1.0"?>
+<domctl_defaults>
+<domain_name>XenoLinux</domain_name>
+<domain_size_kb>16000</domain_size_kb>
+<domain_image>./image</domain_image>
+<domain_vifs>1</domain_vifs>
+<root_device>/dev/nfs</root_device>
+<nw_ip>=+</nw_ip>
+<nw_gw>=</nw_gw>
+<nw_mask>=</nw_mask>
+<nw_nfs_server>128.232.32.20</nw_nfs_server>
+<nw_nfs_root>/usr/groups/srgboot/moonraider/roots/root+</nw_nfs_root>
+<max_domain_number>2</max_domain_number>
+<xi_tools_dir>/tools/internal/</xi_tools_dir>
+</domctl_defaults>
--- /dev/null
+package uk.ac.cam.cl.xeno.domctl;
+
+public abstract class Command
+{
+ public abstract int doCommand(Defaults d, String args[]);
+ public abstract String getName();
+ public abstract String getUsage();
+ public abstract String getHelpText();
+
+ public String getStringParameter(String args[], char key, String def)
+ {
+ String r = getParameter (args, key);
+ return (r == null) ? def : r;
+ }
+
+ public int getIntParameter(String args[], char key, int def)
+ {
+ String r = getParameter (args, key);
+ return (r == null) ? def : (Integer.parseInt (r));
+ }
+
+ public boolean getFlagParameter(String args[], char key)
+ {
+ String r = getParameter (args, key);
+ return (r == null) ? false : true;
+ }
+
+ public String getParameter (String args[], char key)
+ {
+ int i;
+ String result = null;
+ for (i = 0; i < args.length; i ++)
+ {
+ if (args[i].startsWith("-" + key))
+ {
+ if (args[i].length() > 2)
+ {
+ result = args[i].substring(2, args[i].length());
+ }
+ else
+ {
+ result = "";
+ }
+ }
+ }
+ return result;
+ }
+
+ public int reportXIError (String message, String cmd_array[])
+ {
+ int i;
+ System.err.print (message + " using: ");
+ for (i = 0; i < cmd_array.length; i ++) {
+ System.err.print (cmd_array[i] + " ");
+ }
+ System.err.println();
+ return -1;
+ }
+
+ public int reportError (String message)
+ {
+ System.err.println (message);
+ return -1;
+ }
+
+ public void reportCommand (String cmd_array[])
+ {
+ int i;
+ for (i = 0; i < cmd_array.length; i ++) {
+ System.out.print (cmd_array[i] + " ");
+ }
+ System.out.println();
+ }
+}
--- /dev/null
+package uk.ac.cam.cl.xeno.domctl;
+
+import java.io.*;
+import java.net.*;
+
+public class CommandDestroy extends Command
+{
+ public int doCommand(Defaults d, String args[])
+ {
+ Runtime r = Runtime.getRuntime ();
+ int domain_id = getIntParameter(args, 'n', 0);
+ boolean force = getFlagParameter(args, 'f');
+ int rc = 0;
+
+ if (domain_id == 0) {
+ System.err.println ("Expected -n<domain_id>");
+ rc = -1;
+ return rc;
+ }
+
+ try
+ {
+ Process destroy_p;
+ String destroy_cmdarray[] = force ? new String[3] : new String[2];
+ int destroy_rc;
+ int idx = 0;
+ destroy_cmdarray[idx++] = d.XIToolsDir + "xi_destroy";
+ if (force) {
+ destroy_cmdarray[idx++] = "-f";
+ }
+ destroy_cmdarray[idx++] = "" + domain_id;
+
+ if (Settings.TEST) {
+ reportCommand (destroy_cmdarray);
+ } else {
+ destroy_p = r.exec (destroy_cmdarray);
+ destroy_rc = destroy_p.waitFor ();
+
+ if (destroy_rc != 0) {
+ return reportXIError ("Could not destroy domain", destroy_cmdarray);
+ }
+ }
+ }
+ catch (Exception e)
+ {
+ System.err.println ("Could not destroy domain (" + e + ")");
+ e.printStackTrace ();
+ rc = -1;
+ }
+
+ return rc;
+ }
+
+ public String getName()
+ {
+ return "destroy";
+ }
+
+ public String getUsage()
+ {
+ return "[-f] [-n<domain_id>]";
+ }
+
+ public String getHelpText()
+ {
+ return
+ "Destory the specified domain. -f forcibly destroys it.";
+ }
+}
--- /dev/null
+package uk.ac.cam.cl.xeno.domctl;
+
+public class CommandHelp extends Command
+{
+ public int doCommand(Defaults d, String args[])
+ {
+ if (args.length <= 1)
+ {
+ System.out.println ("Usage:");
+ for (int i = 0; i < Main.commands.length; i ++)
+ {
+ String name = Main.commands[i].getName ();
+ String usage = Main.commands[i].getUsage ();
+ while (name.length() < 12) name = name + " ";
+ System.out.println (" " + name + usage);
+ }
+ }
+ else
+ {
+ for (int i = 0; i < Main.commands.length; i ++)
+ {
+ String name = Main.commands[i].getName ();
+ String usage = Main.commands[i].getUsage ();
+ if (name.equals (args[1]))
+ {
+ doHelpFor (Main.commands[i]);
+ break;
+ }
+ }
+ }
+
+ System.out.println ("");
+ return 0;
+ }
+
+ public int doHelpFor (Command c)
+ {
+ System.out.println ("domctl " + c.getName() + " " + c.getUsage());
+ System.out.println ();
+ System.out.println (c.getHelpText ());
+ return 0;
+ }
+
+ public String getName()
+ {
+ return "help";
+ }
+
+ public String getUsage()
+ {
+ return "";
+ }
+
+ public String getHelpText()
+ {
+ return "This message";
+ }
+}
--- /dev/null
+package uk.ac.cam.cl.xeno.domctl;
+
+import java.io.*;
+import java.net.*;
+
+public class CommandNew extends Command
+{
+ public int doCommand(Defaults d, String args[])
+ {
+ Runtime r = Runtime.getRuntime ();
+ String name = getStringParameter(args, 'n', d.domainName);
+ int size = getIntParameter(args, 'k', d.domainSizeKB);
+ String image = getStringParameter(args, 'i', d.domainImage);
+ String initrd = getStringParameter (args, 'r', d.domainInitRD);
+ int vifs = getIntParameter(args, 'v', d.domainVIFs);
+ String bargs = getStringParameter (args, 'a', "");
+ String root_dev = getStringParameter (args, 'd', d.rootDevice);
+ String nfs_root_path = getStringParameter (args, 'f', d.NWNFSRoot);
+ String nw_ip = getStringParameter (args, '4', d.NWIP);
+ String nw_gw = getStringParameter (args, 'g', d.NWGW);
+ String nw_mask = getStringParameter (args, 'm', d.NWMask);
+ String nw_nfs_server = getStringParameter (args, 's', d.NWNFSServer);
+ String nw_host = getStringParameter (args, 'h', d.NWHost);
+ String domain_ip = "";
+ int rc = 0;
+ int domain_id;
+ DataInputStream dis;
+ int idx;
+ int i;
+
+
+ try
+ {
+ /* Some initial sanity checks */
+ if (root_dev.equals ("/dev/nfs") && (vifs == 0)) {
+ return reportError ("Cannot use NFS root without VIFs configured");
+ }
+
+ /* Create a new empty domain */
+ Process create_p;
+ String create_cmdarray[] = new String[3];
+ int create_rc;
+ create_cmdarray[0] = d.XIToolsDir + "xi_create";
+ create_cmdarray[1] = "" + size;
+ create_cmdarray[2] = name;
+ if (Settings.TEST) {
+ reportCommand (create_cmdarray);
+ domain_id=1;
+ create_rc=0;
+ } else {
+ create_p = r.exec (create_cmdarray);
+ dis = new DataInputStream (new BufferedInputStream (create_p.getInputStream ()));
+ domain_id = Integer.parseInt (dis.readLine ());
+ create_rc = create_p.waitFor ();
+ }
+
+ if (create_rc != 0) {
+ return reportXIError ("Failed to create domain", create_cmdarray);
+ } else if (domain_id > d.MaxDomainNumber) {
+ return reportError ("Cannot configure more than " +
+ d.MaxDomainNumber + " domains");
+ }
+
+ /* Set up boot parameters to pass to xi_build. */
+ bargs = "";
+
+ if (root_dev.equals ("/dev/nfs")) {
+ if (vifs == 0) {
+ return reportError ("Cannot use NFS root without VIFs configured");
+ }
+ bargs = (bargs +
+ "root=/dev/nfs " +
+ "nfsroot=" + StringPattern.parse(nfs_root_path).resolve(domain_id) +
+ " ");
+ } else {
+ bargs = ("root=" + StringPattern.parse(root_dev).resolve(domain_id) +
+ " ");
+
+ }
+
+ if (vifs > 0) {
+ domain_ip = InetAddressPattern.parse(nw_ip).resolve(domain_id);
+ if (nw_host == null) {
+ try {
+ nw_host = InetAddress.getByName(domain_ip).getHostName();
+ } catch (UnknownHostException uhe) {
+ nw_host = "" + nw_ip;
+ }
+
+ }
+ bargs = ("ip=" + domain_ip +
+ ":" + InetAddressPattern.parse(nw_nfs_server).resolve(domain_id) +
+ ":" + InetAddressPattern.parse(nw_gw).resolve(domain_id) +
+ ":" + InetAddressPattern.parse(nw_mask).resolve(domain_id) +
+ ":" + nw_host +
+ ":eth0:off " + bargs);
+ }
+
+ /* Build the domain */
+ Process build_p;
+ String build_cmdarray[] = new String[6];
+ int build_rc;
+ idx = 0;
+ for (i = 0; i < build_cmdarray.length; i ++)
+ build_cmdarray[i] = "";
+ build_cmdarray[idx ++] = d.XIToolsDir + "xi_build";
+ build_cmdarray[idx ++] = "" + domain_id;
+ build_cmdarray[idx ++] = "" + image;
+ build_cmdarray[idx ++] = "" + vifs;
+ if (initrd != null) build_cmdarray[idx ++] = "initrd=" + initrd;
+ build_cmdarray[idx ++] = "" + bargs;
+ System.out.println ("Build args: " + bargs);
+ if (Settings.TEST) {
+ reportCommand (build_cmdarray);
+ build_rc = 0;
+ } else {
+ build_p = r.exec (build_cmdarray);
+ build_rc = build_p.waitFor ();
+ }
+
+ if (build_rc != 0) {
+ return reportXIError ("Failed to build domain", build_cmdarray);
+ }
+
+
+ /* Set up the first VIF if necessary */
+ if (vifs > 0) {
+ Process vifinit_p;
+ String vifinit_cmdarray[] = new String[4];
+ int vifinit_rc;
+ vifinit_cmdarray[0] = d.XIToolsDir + "xi_vifinit";
+ vifinit_cmdarray[1] = "" + domain_id;
+ vifinit_cmdarray[2] = "0";
+ vifinit_cmdarray[3] = domain_ip;
+ if (Settings.TEST) {
+ reportCommand (vifinit_cmdarray);
+ vifinit_rc = 0;
+ } else {
+ vifinit_p = r.exec (vifinit_cmdarray);
+ vifinit_rc = vifinit_p.waitFor ();
+ }
+
+ if (vifinit_rc != 0) {
+ return reportXIError ("Failed to initialise VIF 0", vifinit_cmdarray);
+ }
+ }
+ }
+ catch (Exception e)
+ {
+ System.err.println ("Could not create new domain (" + e + ")");
+ e.printStackTrace ();
+ rc = -1;
+ }
+
+ return rc;
+ }
+
+ public String getName()
+ {
+ return "new";
+ }
+
+ public String getUsage()
+ {
+ return "[-n<domain_name>] [-k<size>] [-i<image>] [-v<num_vifs>] [-r<initrd>] [-d<root_device>] [-f<nfs_root>] [-s<nfs_boot_server>] [-4<ipv4_boot_address>] [-g<ipv4_boot_gateway>] [-m<ipv4_boot_netmask>] [-h<hostname>] [-a<args>]";
+ }
+
+ public String getHelpText()
+ {
+ return
+ "Create a new domain. Note that most of the parameters will assume\n" +
+ "default values: it should not be necessary to specify them all. See\n" +
+ "domctl.xml for the current default settings.\n" +
+ "\n" +
+ "General command line options:\n" +
+ " -n Domain name domain_name\n" +
+ " -k Domain size (kb) domain_size_kb\n" +
+ " -i Domain image name domain_image\n" +
+ " -v Number of VIFs domain_vifs\n" +
+ " -r InitRD (if required) domain_init_rd\n" +
+ " -d Root device (e.g /dev/nfs, /dev/hda3) root_device\n" +
+ " -a Additional boot parameters\n" +
+ "\n" +
+ "Networking options:\n" +
+ " -f NFS root (if /dev/nfs specified) nw_nfs_root\n" +
+ " -s NFS server nw_nfs_server\n" +
+ " -4 Domain IPv4 address nw_ip\n" +
+ " -g Domain gateway nw_gw\n" +
+ " -m Domain net mask nw_mask\n" +
+ " -h Domain hostname nw_host\n" +
+ "\n" +
+ "Parameters to -d, -f, -4, -g, -h can be specified as patterns into\n" +
+ "which the allocated domain ID will be incorporated. e.g. for\n" +
+ "domain 1 patterns would expand as follows:\n" +
+ "\n" +
+ " /dev/hda+ /dev/hda1\n" +
+ " /dev/hda7+ /dev/hda8\n" +
+ " 128.232.8.50+ 128.232.8.51\n" +
+ "\n" +
+ "Additionally, patterns for -4 -g -m can include an = which is\n" +
+ "expanded to the corresponding setting from the calling domain.\n";
+ }
+}
--- /dev/null
+package uk.ac.cam.cl.xeno.domctl;
+
+import java.io.*;
+import java.net.*;
+
+public class CommandStart extends Command
+{
+ public int doCommand(Defaults d, String args[])
+ {
+ Runtime r = Runtime.getRuntime ();
+ int domain_id = getIntParameter(args, 'n', 0);
+ int rc = 0;
+
+ if (domain_id == 0) {
+ System.err.println ("Expected -n<domain_id>");
+ rc = -1;
+ return rc;
+ }
+
+ try
+ {
+ Process start_p;
+ String start_cmdarray[] = new String[2];
+ int start_rc;
+ start_cmdarray[0] = d.XIToolsDir + "xi_start";
+ start_cmdarray[1] = "" + domain_id;
+
+ if (Settings.TEST) {
+ reportCommand (start_cmdarray);
+ } else {
+ start_p = r.exec (start_cmdarray);
+ start_rc = start_p.waitFor ();
+ if (start_rc != 0) {
+ return reportXIError ("Could not start domain", start_cmdarray);
+ }
+ }
+ }
+ catch (Exception e)
+ {
+ System.err.println ("Could not start new domain (" + e + ")");
+ e.printStackTrace ();
+ rc = -1;
+ }
+
+ return rc;
+ }
+
+ public String getName()
+ {
+ return "start";
+ }
+
+ public String getUsage()
+ {
+ return "[-n<domain_id>]";
+ }
+
+ public String getHelpText()
+ {
+ return
+ "Start the specified domain.";
+ }
+}
--- /dev/null
+package uk.ac.cam.cl.xeno.domctl;
+
+import java.io.*;
+import java.net.*;
+
+public class CommandStop extends Command
+{
+ public int doCommand(Defaults d, String args[])
+ {
+ Runtime r = Runtime.getRuntime ();
+ int domain_id = getIntParameter(args, 'n', 0);
+ int rc = 0;
+
+ if (domain_id == 0) {
+ System.err.println ("Expected -n<domain_id>");
+ rc = -1;
+ return rc;
+ }
+
+ try
+ {
+ Process stop_p;
+ String stop_cmdarray[] = new String[2];
+ int stop_rc;
+ stop_cmdarray[0] = d.XIToolsDir + "xi_stop";
+ stop_cmdarray[1] = "" + domain_id;
+
+ if (Settings.TEST) {
+ reportCommand (stop_cmdarray);
+ } else {
+ stop_p = r.exec (stop_cmdarray);
+ stop_rc = stop_p.waitFor ();
+
+ if (stop_rc != 0) {
+ return reportXIError ("Could not stop domain", stop_cmdarray);
+ }
+ }
+ }
+ catch (Exception e)
+ {
+ System.err.println ("Could not stop new domain (" + e + ")");
+ e.printStackTrace ();
+ rc = -1;
+ }
+
+ return rc;
+ }
+
+ public String getName()
+ {
+ return "stop";
+ }
+
+ public String getUsage()
+ {
+ return "[-n<domain_id>]";
+ }
+
+ public String getHelpText()
+ {
+ return
+ "Stop the specified domain.";
+ }
+}
--- /dev/null
+package uk.ac.cam.cl.xeno.domctl;
+
+import java.net.InetAddress;
+import java.io.*;
+import org.xml.sax.*;
+import org.xml.sax.helpers.*;
+
+public class Defaults
+{
+ String domainName;
+
+ int domainSizeKB;
+ String domainImage;
+ String domainInitRD;
+ int domainVIFs;
+
+ String rootDevice;
+
+ String NWIP;
+ String NWGW;
+ String NWMask;
+ String NWHost;
+
+ String NWNFSServer;
+ String NWNFSRoot;
+
+ int MaxDomainNumber;
+
+ String XIToolsDir;
+
+ /***********************************************************************/
+
+ public Defaults ()
+ {
+ File f = Settings.getDefaultsFile ();
+ System.out.println ("f=" + f);
+
+ try
+ {
+ XMLReader xr = new org.apache.crimson.parser.XMLReaderImpl();
+ Handler handler = new Handler ();
+ xr.setContentHandler (handler);
+ xr.setErrorHandler (handler);
+ xr.parse (new InputSource(new FileReader (f)));
+ }
+ catch (Exception e)
+ {
+ System.err.println ("Could not read defaults file " + f +
+ "\nException: " + e);
+ e.printStackTrace();
+ System.exit(1);
+ }
+
+ System.out.println ("Domain defaults:");
+ System.out.println (" name " + domainName);
+ System.out.println (" size " + domainSizeKB);
+ System.out.println (" vifs " + domainVIFs);
+ System.out.println (" domainImage " + domainImage);
+ System.out.println (" domainInitRD " + domainInitRD);
+ System.out.println (" rootDevice " + rootDevice);
+ System.out.println (" NWIP " + NWIP);
+ System.out.println (" NWGW " + NWGW);
+ System.out.println (" NWMask " + NWMask);
+ System.out.println (" MaxDomainNumber " + MaxDomainNumber);
+ System.out.println (" NWNFSServer " + NWNFSServer);
+ System.out.println (" NWNFSRoot " + NWNFSRoot);
+ System.out.println (" XIToolsDir " + XIToolsDir);
+ }
+
+ /***********************************************************************/
+
+ class Handler extends DefaultHandler
+ {
+ boolean inDomctlDefaults;
+ String lastName;
+
+ public void startDocument ()
+ {
+ }
+
+ public void endDocument ()
+ {
+ }
+
+ public void startElement (String uri, String name,
+ String qname, Attributes atts)
+ {
+ if (qname.equals ("domctl_defaults")) {
+ inDomctlDefaults = true;
+ } else {
+ lastName = qname;
+ }
+ }
+
+ public void endElement (String uri, String name, String qname)
+ {
+ lastName = "";
+ if (qname.equals ("domctl_defaults")) {
+ inDomctlDefaults = false;
+ }
+ }
+
+ public void characters (char ch[], int start, int length)
+ {
+ String s = new String (ch, start, length);
+ if (lastName != null)
+ {
+ if (lastName.equals ("domain_size_kb")) {
+ domainSizeKB = Integer.parseInt (s);
+ } else if (lastName.equals ("domain_image")) {
+ domainImage = s;
+ } else if (lastName.equals ("domain_name")) {
+ domainName = s;
+ } else if (lastName.equals ("domain_init_rd")) {
+ domainInitRD = s;
+ } else if (lastName.equals ("domain_vifs")) {
+ domainVIFs = Integer.parseInt (s);
+ } else if (lastName.equals ("root_device")) {
+ rootDevice = s;
+ } else if (lastName.equals ("nw_ip")) {
+ NWIP = expandDefault (s, Settings.LOCAL_IP);
+ } else if (lastName.equals ("nw_gw")) {
+ NWGW = expandDefault (s, Settings.LOCAL_GW);
+ } else if (lastName.equals ("nw_mask")) {
+ NWMask = expandDefault (s, Settings.LOCAL_MASK);
+ } else if (lastName.equals ("nw_host")) {
+ NWHost = s;
+ } else if (lastName.equals ("nw_nfs_server")) {
+ NWNFSServer = s;
+ } else if (lastName.equals ("nw_nfs_root")) {
+ NWNFSRoot = s;
+ } else if (lastName.equals ("max_domain_number")) {
+ MaxDomainNumber = Integer.parseInt(s);
+ } else if (lastName.equals ("xi_tools_dir")) {
+ XIToolsDir = s;
+ }
+ }
+ }
+ }
+
+ public String expandDefault (String supplied, String self)
+ {
+ if (supplied.startsWith ("=")) {
+ if (supplied.length() > 1) {
+ return self + supplied.substring (1, supplied.length());
+ } else {
+ return self;
+ }
+ } else {
+ return supplied;
+ }
+ }
+}
--- /dev/null
+package uk.ac.cam.cl.xeno.domctl;
+
+import java.net.*;
+
+public class InetAddressPattern
+{
+ InetAddress base;
+ boolean addDom;
+
+ static InetAddressPattern parse (String t)
+ {
+ InetAddressPattern result = new InetAddressPattern ();
+ char[] ca = t.toCharArray ();
+ int idx = 0;
+ int len = ca.length;
+
+ try {
+ if (len == 0) {
+ result.base = null;
+ result.addDom = false;
+ } else if (ca[len - 1] == '+') {
+ result.base = InetAddress.getByName(t.substring(0, len - 1));
+ result.addDom = true;
+ } else {
+ result.base = InetAddress.getByName(t);
+ result.addDom = false;
+ }
+ } catch (UnknownHostException uhe) {
+ result.base = null;
+ result.addDom = false;
+ }
+
+ return result;
+ }
+
+ public String resolve (int domain_id) {
+ byte b[] = base.getAddress ();
+ if (addDom) {
+ if (((int)b[3]) + domain_id > 255) {
+ if (((int)b[2]) + domain_id > 255) {
+ if (((int)b[1]) + domain_id > 255) {
+ b[0] ++;
+ }
+ b[1] ++;
+ }
+ b[2] ++;
+ }
+ b[3] += domain_id;
+ }
+ return "" +
+ (b[0] + (b[0] < 0 ? 256 : 0)) + "." +
+ (b[1] + (b[1] < 0 ? 256 : 0)) + "." +
+ (b[2] + (b[2] < 0 ? 256 : 0)) + "." +
+ (b[3] + (b[3] < 0 ? 256 : 0));
+ }
+
+ public String toString () {
+ return "[" + base + (addDom ? "+dom_id" : "") + "]";
+ }
+}
--- /dev/null
+package uk.ac.cam.cl.xeno.domctl;
+
+public class Main
+{
+ static CommandHelp help = new CommandHelp ();
+ static CommandNew newdom = new CommandNew ();
+ static CommandStart start = new CommandStart ();
+ static CommandStop stop = new CommandStop ();
+ static CommandDestroy destroy = new CommandDestroy ();
+ static Command commands[] = { help, newdom, start, stop, destroy };
+
+ public static void main (String[] args)
+ {
+ Defaults d = new Defaults ();
+ int ec = -1;
+
+ if (args.length == 0) {
+ ec = help.doCommand (d, args);
+ } else {
+ String c = args[0];
+ int i;
+ for (i = 0; i < commands.length; i ++) {
+ if (commands[i].getName().equals(c)) {
+ if (commands[i].getFlagParameter (args, '?')) {
+ ec = help.doHelpFor (commands[i]);
+ } else {
+ ec = commands[i].doCommand (d, args);
+ }
+ break;
+ }
+ }
+ if (i == commands.length) {
+ System.out.println ("Unknown command " + c);
+ }
+ }
+
+ System.exit (ec);
+ }
+}
--- /dev/null
+package uk.ac.cam.cl.xeno.domctl;
+
+import java.util.*;
+import java.io.*;
+import org.xml.sax.*;
+
+public final class Settings
+{
+ public static final String DEFAULTS_FILE = System.getProperty ("DEFAULTS_FILE");
+ public static final String DEFAULTS_PATH = System.getProperty ("DEFAULTS_PATH");
+ public static final String LOCAL_IP = System.getProperty ("LOCAL_IP");
+ public static final String LOCAL_MASK = System.getProperty ("LOCAL_MASK");
+ public static final String LOCAL_GW = System.getProperty ("LOCAL_ROUTE");
+ public static final boolean TEST = (System.getProperty ("TEST") != null);
+
+
+ public static File getDefaultsFile() {
+ StringTokenizer tok = new StringTokenizer (DEFAULTS_PATH, ":");
+ File result = null;
+ File probe;
+
+ while (tok.hasMoreTokens ()) {
+ String probe_dir = tok.nextToken ();
+ probe = new File (probe_dir, DEFAULTS_FILE);
+ if (probe.exists ()) {
+ result = probe;
+ break;
+ }
+ }
+
+ if (result == null) {
+ System.err.println ("Could not find " + DEFAULTS_FILE + " in path " + DEFAULTS_PATH);
+ System.exit (1);
+ }
+
+ return result;
+ }
+}
--- /dev/null
+package uk.ac.cam.cl.xeno.domctl;
+
+public class StringPattern
+{
+ String base;
+ int bn;
+ boolean addDom;
+ boolean appendDom;
+
+ static StringPattern parse (String t)
+ {
+ StringPattern result = new StringPattern ();
+ char[] ca = t.toCharArray ();
+ int idx = 0;
+ int len = ca.length;
+
+ if (len == 0) {
+ result.base = "";
+ result.bn = 0;
+ result.addDom = false;
+ } else if (ca[len - 1] == '+') {
+ idx = len - 2;
+ if ((idx >= 0) && (ca[idx] >= '0') && (ca[idx] <= '9')) {
+ while ((idx >= 0) && (ca[idx] >= '0') && (ca[idx] <= '9')) {
+ idx --;
+ }
+ result.base = t.substring(0, idx + 1);
+ result.bn = Integer.parseInt (t.substring (idx + 1, len - 1));
+ result.addDom = true;
+ } else {
+ result.base = t.substring(0, len - 1);
+ result.appendDom = true;
+ }
+ } else {
+ result.base = t;
+ }
+
+ return result;
+ }
+
+ public String resolve (int domain_id) {
+ if (addDom) {
+ return base + (bn + domain_id);
+ } else if (appendDom) {
+ return base + domain_id;
+ } else {
+ return base;
+ }
+ }
+
+ public String toString () {
+ return ("[" +
+ base +
+ (addDom ? "+" + bn : "") +
+ ((addDom || appendDom) ? "+ID" : "") +
+ "]");
+ }
+
+}
--- /dev/null
+CC = gcc
+XI_CREATE = xi_create
+XI_START = xi_start
+XI_STOP = xi_stop
+XI_DESTROY = xi_destroy
+XI_BUILD = xi_build
+
+all: $(XI_CREATE).o $(XI_START).o $(XI_STOP).o $(XI_DESTROY).o $(XI_BUILD).o
+ $(CC) -o $(XI_CREATE) $(XI_CREATE).o
+ $(CC) -o $(XI_BUILD) $(XI_BUILD).o
+ $(CC) -o $(XI_START) $(XI_START).o
+ $(CC) -o $(XI_STOP) $(XI_STOP).o
+ $(CC) -o $(XI_DESTROY) $(XI_DESTROY).o
+
+$(XI_CREATE).o: $(XI_CREATE).c dom0_defs.h dom0_ops.h hypervisor_defs.h mem_defs.h
+ $(CC) -c $(XI_CREATE).c
+
+internal_domain_build.o: internal_domain_build.c dom0_defs.h dom0_ops.h hypervisor_defs.h mem_defs.h
+ $(CC) -c internal_domain_build.c
+
+$(XI_START).o: $(XI_START).c dom0_defs.h dom0_ops.h hypervisor_defs.h mem_defs.h
+ $(CC) -c $(XI_START).c
+
+$(XI_STOP).o: $(XI_STOP).c dom0_defs.h dom0_ops.h hypervisor_defs.h mem_defs.h
+ $(CC) -c $(XI_STOP).c
+
+$(XI_DESTROY).o: $(XI_DESTROY).c dom0_ops.h dom0_defs.h
+ $(CC) -c $(XI_DESTROY).c
+
+clean:
+ $(RM) *.o $(XI_CREATE) $(XI_START) $(XI_STOP) $(XI_DESTROY) $(XI_BUILD)
+
--- /dev/null
+#define PROC_XENO_ROOT "xeno"
+#define PROC_CMD "dom0_cmd"
+#define PROC_DOM_PREFIX "dom"
+#define PROC_DOM_MEM "mem"
+#define PROC_DOM_DATA "new_dom_data"
+#define PROC_DOMAINS "domains"
+
+#define MAX_PATH 256
+
--- /dev/null
+/******************************************************************************
+ * hypervisor_defs.h
+ *
+ * This needs to be kept in sync with Xen's pagetable update interface!
+ *
+ * Copyright (c) 2002-2003, Keir Fraser & Boris Dragovic
+ */
+
+/* taken from include/hypervisor-ifs/hypervisor-if.h */
+typedef struct
+{
+/*
+ * PGREQ_XXX: specified in least-significant bits of 'ptr' field. All requests
+ * specify relevent PTE or PT address in 'ptr'. Normal requests specify update
+ * value in 'value'. Extended requests specify command in least 8 bits of
+ * 'value'.
+ */
+ unsigned long ptr, val; /* *ptr = val */
+} page_update_request_t;
+
+/* A normal page-table update request. */
+#define PGREQ_NORMAL 0
+#define PGREQ_MPT_UPDATE 1
+/* An extended command. */
+#define PGREQ_EXTENDED_COMMAND 2
+/* Announce a new top-level page table. */
+#define PGEXT_PIN_L1_TABLE 0
+#define PGEXT_PIN_L2_TABLE 1
+#define PGEXT_PIN_L3_TABLE 2
+#define PGEXT_PIN_L4_TABLE 3
+#define PGEXT_UNPIN_TABLE 4
+#define PGEXT_NEW_BASEPTR 5
+#define PGEXT_TLB_FLUSH 6
+#define PGEXT_INVLPG 7
+#define PGEXT_CMD_MASK 255
+#define PGEXT_CMD_SHIFT 8
--- /dev/null
+/*
+ * memory related definitions needed for userspace domain builder dom0 application. these _need_ to
+ * be kept in sync with the kernel .h files they were copied over from or something horrible will
+ * happen. remmember: god kills a kitten every time you forget to keep these in sync.
+ *
+ * KAF: Boris, these constants are all fixed by x86 hardware. So the kittens are safe for now :-)
+ *
+ * Copyright 2002 by B Dragovic
+ */
+
+/* copied over from hypervisor: include/asm-i386/page.h */
+
+#define _PAGE_PRESENT 0x001
+#define _PAGE_RW 0x002
+#define _PAGE_USER 0x004
+#define _PAGE_PWT 0x008
+#define _PAGE_PCD 0x010
+#define _PAGE_ACCESSED 0x020
+#define _PAGE_DIRTY 0x040
+#define _PAGE_PAT 0x080
+#define _PAGE_PSE 0x080
+#define _PAGE_GLOBAL 0x100
+
+
+#define L1_PAGETABLE_SHIFT 12
+#define L2_PAGETABLE_SHIFT 22
+
+#define ENTRIES_PER_L1_PAGETABLE 1024
+#define ENTRIES_PER_L2_PAGETABLE 1024
+
+#define PAGE_SHIFT L1_PAGETABLE_SHIFT
+#define PAGE_SIZE (1UL << PAGE_SHIFT)
+#define PAGE_MASK (~(PAGE_SIZE-1))
+
+typedef struct { unsigned long l1_lo; } l1_pgentry_t;
+typedef struct { unsigned long l2_lo; } l2_pgentry_t;
+
+#define l1_table_offset(_a) \
+ (((_a) >> L1_PAGETABLE_SHIFT) & (ENTRIES_PER_L1_PAGETABLE - 1))
+#define l2_table_offset(_a) \
+ ((_a) >> L2_PAGETABLE_SHIFT)
+
+/* local definitions */
+
+#define nr_2_page(x) (x << PAGE_SHIFT)
--- /dev/null
+/*
+ * XenoDomainBuilder, copyright (c) Boris Dragovic, bd240@cl.cam.ac.uk
+ * This code is released under terms and conditions of GNU GPL :).
+ * Usage: <executable> <mem_kb> <os image> <num_vifs>
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+
+#include "hypervisor_defs.h"
+#include "dom0_ops.h"
+#include "dom0_defs.h"
+#include "mem_defs.h"
+
+#define PERR_STRING "Xeno Domain Builder"
+
+#define GUEST_SIG "XenoGues"
+#define SIG_LEN 8
+
+/*
+ * NB. No ring-3 access in initial guestOS pagetables. Note that we allow
+ * ring-3 privileges in the page directories, so that the guestOS may later
+ * decide to share a 4MB region with applications.
+ */
+#define L1_PROT (_PAGE_PRESENT|_PAGE_RW|_PAGE_ACCESSED)
+#define L2_PROT (_PAGE_PRESENT|_PAGE_RW|_PAGE_ACCESSED|_PAGE_DIRTY|_PAGE_USER)
+
+/* standardized error reporting function */
+static void dberr(char *msg)
+{
+ printf("%s: %s\n", PERR_STRING, msg);
+}
+
+/* status reporting function */
+static void dbstatus(char * msg)
+{
+ printf("Domain Builder: %s\n", msg);
+}
+
+
+/* clean up domain's memory allocations */
+static void dom_mem_cleanup(dom_mem_t * dom_mem)
+{
+ char mem_path[MAX_PATH];
+ int mem_fd;
+
+ /* open the domain's /proc mem interface */
+ sprintf(mem_path, "%s%s%s%s%d%s%s", "/proc/", PROC_XENO_ROOT, "/",
+ PROC_DOM_PREFIX, dom_mem->domain, "/", PROC_DOM_MEM);
+
+ mem_fd = open(mem_path, O_WRONLY);
+ if(mem_fd < 0){
+ perror(PERR_STRING);
+ }
+
+ if(write(mem_fd, (dom_mem_t *)dom_mem, sizeof(dom_mem_t)) < 0){
+ dbstatus("Error unmapping domain's memory.\n");
+ }
+
+ close(mem_fd);
+}
+
+/* ask dom0 to export domains memory through /proc */
+static int setup_dom_memmap(unsigned long pfn, int pages, int dom)
+{
+ char cmd_path[MAX_PATH];
+ dom0_op_t dop;
+ int cmd_fd;
+
+ dop.cmd = MAP_DOM_MEM;
+ dop.u.dommem.start_pfn = pfn;
+ dop.u.dommem.tot_pages = pages;
+ dop.u.dommem.domain = dom;
+
+ /* open the /proc command interface */
+ sprintf(cmd_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_CMD);
+ cmd_fd = open(cmd_path, O_WRONLY);
+ if(cmd_fd < 0){
+ perror(PERR_STRING);
+ return -1;
+ }
+
+ write(cmd_fd, &dop, sizeof(dom0_op_t));
+ close(cmd_fd);
+
+ return 0;
+}
+
+/* request the actual mapping from dom0 */
+static unsigned long get_vaddr(unsigned int dom)
+{
+ char mem_path[MAX_PATH];
+ unsigned long addr;
+ int mem_fd;
+
+ /* open the domain's /proc mem interface */
+ sprintf(mem_path, "%s%s%s%s%d%s%s", "/proc/", PROC_XENO_ROOT, "/",
+ PROC_DOM_PREFIX, dom, "/", PROC_DOM_MEM);
+
+ mem_fd = open(mem_path, O_RDONLY);
+ if(mem_fd < 0){
+ perror(PERR_STRING);
+ return 0;
+ }
+
+ /* get virtual address of mapped region */
+ read(mem_fd, &addr, sizeof(addr));
+
+ close(mem_fd);
+
+ return addr;
+}
+
+static int map_dom_mem(unsigned long pfn, int pages, int dom,
+ dom_mem_t * dom_mem)
+{
+
+ if(setup_dom_memmap(pfn, pages, dom)){
+ perror(PERR_STRING);
+ return -1;
+ }
+
+ dom_mem->domain = dom;
+ dom_mem->start_pfn = pfn;
+ dom_mem->tot_pages = pages;
+ if((dom_mem->vaddr = get_vaddr(dom)) == 0){
+ dberr("Error mapping dom memory.");
+ return -1;
+ }
+
+ return 0;
+}
+
+/* open kernel image and do some sanity checks */
+static int do_kernel_chcks(char *image, long dom_size,
+ unsigned long * load_addr, size_t * ksize)
+{
+ char signature[8];
+ char status[MAX_PATH];
+ struct stat stat;
+ int fd;
+ int ret;
+
+ fd = open(image, O_RDONLY);
+ if(fd < 0){
+ perror(PERR_STRING);
+ ret = -1;
+ goto out;
+ }
+
+ if(fstat(fd, &stat) < 0){
+ perror(PERR_STRING);
+ ret = -1;
+ close(fd);
+ goto out;
+ }
+
+ if(stat.st_size > (dom_size << 10)){
+ sprintf(status, "Kernel image size %ld larger than requested "
+ "domain size %ld\n Terminated.\n", stat.st_size, dom_size);
+ dberr(status);
+ ret = -1;
+ close(fd);
+ goto out;
+ }
+
+ read(fd, signature, SIG_LEN);
+ if(strncmp(signature, GUEST_SIG, SIG_LEN)){
+ dberr("Kernel image does not contain required signature. "
+ "Terminating.\n");
+ ret = -1;
+ close(fd);
+ goto out;
+ }
+
+ read(fd, load_addr, sizeof(unsigned long));
+
+ *ksize = stat.st_size - SIG_LEN - sizeof(unsigned long);
+
+ ret = fd;
+
+out:
+ return ret;
+}
+
+/* this is the main guestos setup function,
+ * returnes domain descriptor structure to be used when launching
+ * the domain by hypervisor to do some last minute initialization.
+ * page table initialization is done by making a list of page table
+ * requests that are handeled by the hypervisor in the ordinary
+ * manner. this way, many potentially messy things are avoided...
+ */
+#define PAGE_TO_VADDR(_pfn) ((void *)(dom_mem->vaddr + ((_pfn) * PAGE_SIZE)))
+static dom_meminfo_t *setup_guestos(int dom, int kernel_fd, int initrd_fd,
+ unsigned long virt_load_addr, size_t ksize, dom_mem_t *dom_mem)
+{
+ dom_meminfo_t *meminfo;
+ unsigned long *page_array;
+ page_update_request_t *pgt_updates;
+ dom_mem_t mem_map;
+ dom_meminfo_t *ret = NULL;
+ int alloc_index, num_pt_pages;
+ unsigned long l2tab;
+ unsigned long l1tab = 0;
+ unsigned long num_pgt_updates = 0;
+ unsigned long count, pt_start;
+ dom0_op_t pgupdate_req;
+ char cmd_path[MAX_PATH];
+ int cmd_fd;
+
+ meminfo = (dom_meminfo_t *)malloc(sizeof(dom_meminfo_t));
+ page_array = malloc(dom_mem->tot_pages * 4);
+ pgt_updates = (page_update_request_t *)dom_mem->vaddr;
+ alloc_index = dom_mem->tot_pages - 1;
+
+ memset(meminfo, 0, sizeof(meminfo));
+
+ memcpy(page_array, (void *)dom_mem->vaddr, dom_mem->tot_pages * 4);
+
+ /* Count bottom-level PTs, rounding up. Include one PTE for shared info. */
+ num_pt_pages =
+ (l1_table_offset(virt_load_addr) + dom_mem->tot_pages + 1024) / 1024;
+
+ /* We must also count the page directory. */
+ num_pt_pages++;
+
+ /* Index of first PT page. */
+ pt_start = dom_mem->tot_pages - num_pt_pages;
+
+ /* first allocate page for page dir. allocation goes backwards from the
+ * end of the allocated physical address space.
+ */
+ l2tab = *(page_array + alloc_index) << PAGE_SHIFT;
+ memset(PAGE_TO_VADDR(alloc_index), 0, PAGE_SIZE);
+ alloc_index--;
+ meminfo->l2_pgt_addr = l2tab;
+ meminfo->virt_shinfo_addr = virt_load_addr + nr_2_page(dom_mem->tot_pages);
+
+ /* pin down l2tab addr as page dir page - causes hypervisor to provide
+ * correct protection for the page
+ */
+ pgt_updates->ptr = l2tab | PGREQ_EXTENDED_COMMAND;
+ pgt_updates->val = PGEXT_PIN_L2_TABLE;
+ pgt_updates++;
+ num_pgt_updates++;
+
+ /*
+ * Initialise the page tables. The final iteration is for the shared_info
+ * PTE -- we break out before filling in the entry, as that is done by
+ * Xen during final setup.
+ */
+ l2tab += l2_table_offset(virt_load_addr) * sizeof(l2_pgentry_t);
+ for ( count = 0; count < (dom_mem->tot_pages + 1); count++ )
+ {
+ if ( !((unsigned long)l1tab & (PAGE_SIZE-1)) )
+ {
+ l1tab = *(page_array + alloc_index) << PAGE_SHIFT;
+ memset(PAGE_TO_VADDR(alloc_index), 0, PAGE_SIZE);
+ alloc_index--;
+
+ l1tab += l1_table_offset(virt_load_addr + nr_2_page(count))
+ * sizeof(l1_pgentry_t);
+
+ /* make apropriate entry in the page directory */
+ pgt_updates->ptr = l2tab;
+ pgt_updates->val = l1tab | L2_PROT;
+ pgt_updates++;
+ num_pgt_updates++;
+ l2tab += sizeof(l2_pgentry_t);
+ }
+
+ /* The last PTE we consider is filled in later by Xen. */
+ if ( count == dom_mem->tot_pages ) break;
+
+ if ( count < pt_start )
+ {
+ pgt_updates->ptr = l1tab;
+ pgt_updates->val = (*(page_array + count) << PAGE_SHIFT) | L1_PROT;
+ pgt_updates++;
+ num_pgt_updates++;
+ l1tab += sizeof(l1_pgentry_t);
+ }
+ else
+ {
+ pgt_updates->ptr = l1tab;
+ pgt_updates->val =
+ ((*(page_array + count) << PAGE_SHIFT) | L1_PROT) & ~_PAGE_RW;
+ pgt_updates++;
+ num_pgt_updates++;
+ l1tab += sizeof(l1_pgentry_t);
+ }
+
+ pgt_updates->ptr =
+ (*(page_array + count) << PAGE_SHIFT) | PGREQ_MPT_UPDATE;
+ pgt_updates->val = count;
+ pgt_updates++;
+ num_pgt_updates++;
+ }
+
+ meminfo->virt_startinfo_addr = virt_load_addr + nr_2_page(alloc_index - 1);
+ meminfo->domain = dom;
+
+ /*
+ * Send the page update requests down to the hypervisor.
+ * NB. We must do this before loading the guest OS image!
+ */
+ sprintf(cmd_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_CMD);
+ if ( (cmd_fd = open(cmd_path, O_WRONLY)) < 0 ) goto out;
+ pgupdate_req.cmd = DO_PGUPDATES;
+ pgupdate_req.u.pgupdate.pgt_update_arr = (unsigned long)dom_mem->vaddr;
+ pgupdate_req.u.pgupdate.num_pgt_updates = num_pgt_updates;
+ write(cmd_fd, &pgupdate_req, sizeof(dom0_op_t));
+ close(cmd_fd);
+
+ /* Load the guest OS image. */
+ if( read(kernel_fd, (char *)dom_mem->vaddr, ksize) != ksize )
+ {
+ dberr("Error reading kernel image, could not"
+ " read the whole image. Terminating.\n");
+ goto out;
+ }
+
+ if( initrd_fd )
+ {
+ struct stat stat;
+ unsigned long isize;
+
+ if(fstat(initrd_fd, &stat) < 0){
+ perror(PERR_STRING);
+ close(initrd_fd);
+ goto out;
+ }
+ isize = stat.st_size;
+
+ if( read(initrd_fd, ((char *)dom_mem->vaddr)+ksize, isize) != isize )
+ {
+ dberr("Error reading initrd image, could not"
+ " read the whole image. Terminating.\n");
+ goto out;
+ }
+
+ meminfo->virt_mod_addr = virt_load_addr + ksize;
+ meminfo->virt_mod_len = isize;
+
+ }
+
+
+ ret = meminfo;
+out:
+
+ return ret;
+}
+
+static int launch_domain(dom_meminfo_t * meminfo)
+{
+ char cmd_path[MAX_PATH];
+ dom0_op_t dop;
+ int cmd_fd;
+
+ sprintf(cmd_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_CMD);
+ cmd_fd = open(cmd_path, O_WRONLY);
+ if(cmd_fd < 0){
+ perror(PERR_STRING);
+ return -1;
+ }
+
+ dop.cmd = DOM0_BUILDDOMAIN;
+ memcpy(&dop.u.meminfo, meminfo, sizeof(dom_meminfo_t));
+ write(cmd_fd, &dop, sizeof(dom0_op_t));
+ close(cmd_fd);
+
+ return 0;
+}
+
+static int get_domain_info (int domain_id,
+ int *pg_head,
+ int *tot_pages)
+{
+ FILE *f;
+ char domains_path[MAX_PATH];
+ char domains_line[256];
+ int rc = -1;
+ int read_id;
+
+ sprintf (domains_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_DOMAINS
+);
+
+ f = fopen (domains_path, "r");
+ if (f == NULL) goto out;
+
+ read_id = -1;
+ while (fgets (domains_line, 256, f) != 0)
+ {
+ int trans;
+ trans = sscanf (domains_line, "%d %*d %*d %*d %*d %*d %x %d %*s", &read_id
+, pg_head, tot_pages);
+ if (trans == 3) {
+ if (read_id == domain_id) {
+ rc = 0;
+ break;
+ }
+ }
+ }
+
+ if (read_id == -1) {
+ errno = ESRCH;
+ }
+
+ fclose (f);
+
+ out:
+ return rc;
+}
+
+
+int main(int argc, char **argv)
+{
+
+ dom_mem_t dom_os_image;
+ dom_mem_t dom_pgt;
+ dom_meminfo_t * meminfo;
+ size_t ksize;
+ unsigned long load_addr;
+ char status[1024];
+ int kernel_fd, initrd_fd = 0;
+ int count;
+ int cmd_len;
+ int rc = -1;
+ int args_start = 4;
+ char initrd_name[1024];
+ int domain_id;
+ int pg_head;
+ int tot_pages;
+
+ unsigned long addr;
+
+ /**** this argument parsing code is really _gross_. rewrite me! ****/
+
+ if(argc < 4) {
+ dberr("Usage: dom_builder <domain_id> <image> <num_vifs> "
+ "[<initrd=initrd_name>] <boot_params>\n");
+ return -1;
+ }
+
+ /* Look up information about the domain */
+ domain_id = atol(argv[1]);
+ if (get_domain_info (domain_id, &pg_head, &tot_pages) != 0) {
+ perror ("Could not find domain information");
+ rc = -1;
+ goto out;
+ }
+
+ kernel_fd = do_kernel_chcks(argv[2], tot_pages << (PAGE_SHIFT - 10), &load_addr, &ksize);
+ if(kernel_fd < 0)
+ return -1;
+
+
+ /* map domain's memory */
+ if(map_dom_mem(pg_head, tot_pages,
+ domain_id, &dom_os_image))
+ goto out;
+
+ if( strncmp("initrd=", argv[args_start], 7) == 0 )
+ {
+ strncpy( initrd_name, argv[args_start]+7, sizeof(initrd_name) );
+ initrd_name[sizeof(initrd_name)-1] = 0;
+ printf("initrd present, name = %s\n", initrd_name );
+ args_start++;
+
+ initrd_fd = open(initrd_name, O_RDONLY);
+ if(initrd_fd < 0){
+ perror(PERR_STRING);
+ goto out;
+ }
+ }
+
+ /* the following code does the actual domain building */
+ meminfo = setup_guestos(domain_id, kernel_fd, initrd_fd, load_addr,
+ ksize, &dom_os_image);
+
+ /* and unmap the new domain's memory image since we no longer need it */
+ dom_mem_cleanup(&dom_os_image);
+
+ if(!meminfo) {
+ printf("Domain Builder: debug: meminfo NULL\n");
+ goto out;
+ }
+
+ meminfo->virt_load_addr = load_addr;
+ meminfo->num_vifs = atoi(argv[3]);
+ meminfo->cmd_line[0] = '\0';
+ cmd_len = 0;
+ for(count = args_start; count < argc; count++){
+ if(cmd_len + strlen(argv[count]) > MAX_CMD_LEN - 1){
+ dberr("Size of image boot params too big!\n");
+ break;
+ }
+ strcat(meminfo->cmd_line, argv[count]);
+ strcat(meminfo->cmd_line, " ");
+ cmd_len += strlen(argv[count] + 1);
+ }
+
+ /* sprintf(status,
+ "About to launch new domain %d with folowing parameters:\n"
+ " * page table base: %lx \n * load address: %lx \n"
+ " * shared info address: %lx \n * start info address: %lx \n"
+ " * number of vifs: %d \n * cmd line: %s \n", meminfo->domain,
+ meminfo->l2_pgt_addr, meminfo->virt_load_addr,
+ meminfo->virt_shinfo_addr, meminfo->virt_startinfo_addr,
+ meminfo->num_vifs, meminfo->cmd_line);
+ dbstatus(status);*/
+
+ /* and launch the domain */
+ rc = launch_domain(meminfo);
+
+out:
+ return rc;
+}
--- /dev/null
+/*
+ * XenoDomainBuilder, copyright (c) Boris Dragovic, bd240@cl.cam.ac.uk
+ * This code is released under terms and conditions of GNU GPL :).
+ * Usage: <executable> <mem_kb> <os image> <num_vifs>
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+
+#include "hypervisor_defs.h"
+#include "dom0_ops.h"
+#include "dom0_defs.h"
+#include "mem_defs.h"
+
+/***********************************************************************/
+
+static char *argv0 = "internal_domain_create";
+
+static void ERROR (char *message)
+{
+ fprintf (stderr, "%s: %s\n", argv0, message);
+ exit (-1);
+}
+
+static void PERROR (char *message)
+{
+ fprintf (stderr, "%s: %s (%s)\n", argv0, message, sys_errlist[errno]);
+ exit (-1);
+}
+
+/***********************************************************************/
+
+static dom0_newdomain_t * create_new_domain(long req_mem, char *name)
+{
+ dom0_newdomain_t * dom_data;
+ char cmd_path[MAX_PATH];
+ char dom_id_path[MAX_PATH];
+ dom0_op_t dop;
+ int cmd_fd;
+ int id_fd;
+
+ /* open the /proc command interface */
+ sprintf(cmd_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_CMD);
+ cmd_fd = open(cmd_path, O_WRONLY);
+ if(cmd_fd < 0){
+ PERROR ("Could not open PROC_CMD interface");
+ return 0;
+ }
+
+ dop.cmd = DOM0_CREATEDOMAIN;
+ dop.u.newdomain.memory_kb = req_mem;
+ strncpy (dop.u.newdomain.name, name, MAX_DOMAIN_NAME - 1);
+ dop.u.newdomain.name[MAX_DOMAIN_NAME - 1] = 0;
+
+ write(cmd_fd, &dop, sizeof(dom0_op_t));
+ close(cmd_fd);
+
+ sprintf(dom_id_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/",
+ PROC_DOM_DATA);
+ while((id_fd = open(dom_id_path, O_RDONLY)) < 0) continue;
+ dom_data = (dom0_newdomain_t *)malloc(sizeof(dom0_newdomain_t));
+ read(id_fd, dom_data, sizeof(dom0_newdomain_t));
+ close(id_fd);
+
+ return dom_data;
+}
+
+/***********************************************************************/
+
+int main(int argc, char **argv)
+{
+ dom0_newdomain_t * dom_data;
+
+ if (argv[0] != NULL)
+ {
+ argv0 = argv[0];
+ }
+
+ if(argc != 3)
+ {
+ fprintf (stderr, "Usage: %s <kbytes-mem> <domain-name>\n", argv0);
+ return -1;
+ }
+
+ if(!(dom_data = create_new_domain(atol(argv[1]), argv[2])))
+ {
+ return -1;
+ }
+
+ fprintf (stdout, "%d\n", dom_data -> domain);
+ return 0;
+}
--- /dev/null
+/*
+ * A very(!) simple program to kill a domain. (c) Boris Dragovic
+ * Usage: <executable> <mem_kb> <os image> <num_vifs>
+ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include "dom0_ops.h"
+#include "dom0_defs.h"
+
+/***********************************************************************/
+
+static char *argv0 = "internal_domain_stop";
+
+static void ERROR (char *message)
+{
+ fprintf (stderr, "%s: %s\n", argv0, message);
+ exit (-1);
+}
+
+static void PERROR (char *message)
+{
+ fprintf (stderr, "%s: %s (%s)\n", argv0, message, sys_errlist[errno]);
+ exit (-1);
+}
+
+/***********************************************************************/
+
+static int do_kill_domain(int dom_id, int force)
+{
+ char cmd_path[MAX_PATH];
+ dom0_op_t dop;
+ int cmd_fd;
+
+ dop.cmd = DOM0_DESTROYDOMAIN;
+ dop.u.killdomain.domain = dom_id;
+ dop.u.killdomain.force = force;
+
+ /* open the /proc command interface */
+ sprintf(cmd_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_CMD);
+ cmd_fd = open(cmd_path, O_WRONLY);
+ if(cmd_fd < 0){
+ PERROR ("Count not open PROC_CMD interface");
+ }
+
+ write(cmd_fd, &dop, sizeof(dom0_op_t));
+ close(cmd_fd);
+
+ return 0;
+}
+
+int main(int argc, char **argv)
+{
+ int ret;
+
+ if (argv[0] != NULL)
+ {
+ argv0 = argv[0];
+ }
+
+ if ( (argc < 2) || (argc > 3) )
+ {
+ usage:
+ fprintf(stderr, "Usage: %s [-f] <domain_id>\n", argv0);
+ fprintf(stderr, " -f: Forces immediate destruction of specified domain\n");
+ ret = -1;
+ goto out;
+ }
+
+ if ( (argc == 3) && strcmp("-f", argv[1]) ) goto usage;
+
+ ret = do_kill_domain(atoi(argv[argc-1]), argc == 3);
+
+out:
+ return ret;
+}
--- /dev/null
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+
+#include "hypervisor_defs.h"
+#include "dom0_ops.h"
+#include "dom0_defs.h"
+#include "mem_defs.h"
+
+/***********************************************************************/
+
+static char *argv0 = "internal_domain_start";
+
+static void ERROR (char *message)
+{
+ fprintf (stderr, "%s: %s\n", argv0, message);
+ exit (-1);
+}
+
+static void PERROR (char *message)
+{
+ fprintf (stderr, "%s: %s (%s)\n", argv0, message, sys_errlist[errno]);
+ exit (-1);
+}
+
+/***********************************************************************/
+
+static int start_domain(int id)
+{
+ dom0_newdomain_t * dom_data;
+ char cmd_path[MAX_PATH];
+ char dom_id_path[MAX_PATH];
+ dom0_op_t dop;
+ int cmd_fd;
+ int id_fd;
+
+ /* Set up the DOM0_STARTDOMAIN command */
+ dop.cmd = DOM0_STARTDOMAIN;
+ dop.u.meminfo.domain = id;
+
+ /* open the /proc command interface */
+ sprintf(cmd_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_CMD);
+ cmd_fd = open(cmd_path, O_WRONLY);
+ if(cmd_fd < 0){
+ PERROR ("Count not open PROC_CMD interface");
+ }
+
+ /* Issue the command */
+ write(cmd_fd, &dop, sizeof(dom0_op_t));
+ close(cmd_fd);
+
+ return 0;
+}
+
+/***********************************************************************/
+
+int main(int argc, char **argv)
+{
+ int rc;
+
+ if (argv[0] != NULL)
+ {
+ argv0 = argv[0];
+ }
+
+ if(argc != 2)
+ {
+ fprintf (stderr, "Usage: %s <domain-id>\n", argv0);
+ return -1;
+ }
+
+ rc = start_domain(atol(argv[1]));
+
+ return rc;
+}
--- /dev/null
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <stdlib.h>
+
+#include "hypervisor_defs.h"
+#include "dom0_ops.h"
+#include "dom0_defs.h"
+#include "mem_defs.h"
+
+/***********************************************************************/
+
+static char *argv0 = "internal_domain_stop";
+
+static void ERROR (char *message)
+{
+ fprintf (stderr, "%s: %s\n", argv0, message);
+ exit (-1);
+}
+
+static void PERROR (char *message)
+{
+ fprintf (stderr, "%s: %s (%s)\n", argv0, message, sys_errlist[errno]);
+ exit (-1);
+}
+
+/***********************************************************************/
+
+static int stop_domain(int id)
+{
+ dom0_newdomain_t * dom_data;
+ char cmd_path[MAX_PATH];
+ char dom_id_path[MAX_PATH];
+ dom0_op_t dop;
+ int cmd_fd;
+ int id_fd;
+
+ /* Set up the DOM0_STOPDOMAIN command */
+ dop.cmd = DOM0_STOPDOMAIN;
+ dop.u.meminfo.domain = id;
+
+ /* open the /proc command interface */
+ sprintf(cmd_path, "%s%s%s%s", "/proc/", PROC_XENO_ROOT, "/", PROC_CMD);
+ cmd_fd = open(cmd_path, O_WRONLY);
+ if(cmd_fd < 0){
+ PERROR ("Count not open PROC_CMD interface");
+ }
+
+ /* Issue the command */
+ write(cmd_fd, &dop, sizeof(dom0_op_t));
+ close(cmd_fd);
+
+ return 0;
+}
+
+/***********************************************************************/
+
+int main(int argc, char **argv)
+{
+ int rc;
+
+ if (argv[0] != NULL)
+ {
+ argv0 = argv[0];
+ }
+
+ if(argc != 2)
+ {
+ fprintf (stderr, "Usage: %s <domain-id>\n", argv0);
+ return -1;
+ }
+
+ rc = stop_domain(atol(argv[1]));
+
+ return rc;
+}
--- /dev/null
+#!/bin/bash
+#
+# vifinit
+#
+# This is a silly little script to dump a couple of simple rules down to
+# the hypervisor to assign a full static IP to a given virtual interface.
+#
+# Usage is:
+#
+# vifinit [vif dom] [vif idx] [dotted decimal ip address]
+#
+if [ $# -ne 3 ] ;
+then
+ echo "usage: $0 <domain_id> <vid_ifx> <dotted_decimal_ip_address>"
+ exit
+fi
+
+#outbound rule:
+echo "ADD ACCEPT srcaddr=$3 srcaddrmask=255.255.255.255 srcdom=$1 srcidx=$2 dst=PHYS proto=any" > /proc/vfr
+
+#inbound rule:
+echo "ADD ACCEPT dstaddr=$3 dstaddrmask=255.255.255.255 src=ANY dstdom=$1 dstidx=$2 proto=any" > /proc/vfr
+
+#----] done.
+
switch ( op.cmd )
{
- case DOM0_STARTDOM:
+ case DOM0_BUILDDOMAIN:
{
struct task_struct * p = find_domain_by_id(op.u.meminfo.domain);
if ( (ret = final_setup_guestos(p, &op.u.meminfo)) != 0 )
break;
+ ret = p->domain;
+ free_task_struct(p);
+ }
+ break;
+
+ case DOM0_STARTDOMAIN:
+ {
+ struct task_struct * p = find_domain_by_id(op.u.meminfo.domain);
wake_up(p);
reschedule(p);
ret = p->domain;
}
break;
- case DOM0_NEWDOMAIN:
+ case DOM0_STOPDOMAIN:
+ {
+ ret = stop_other_domain (op.u.meminfo.domain);
+ }
+ break;
+
+ case DOM0_CREATEDOMAIN:
{
struct task_struct *p;
static unsigned int pro = 0;
if ( p == NULL )
break;
+ if (op.u.newdomain.name[0]) {
+ strncpy (p -> name, op.u.newdomain.name, MAX_DOMAIN_NAME);
+ p -> name[MAX_DOMAIN_NAME - 1] = 0;
+ }
+
ret = alloc_new_dom_mem(p, op.u.newdomain.memory_kb);
if ( ret != 0 )
{
}
break;
- case DOM0_KILLDOMAIN:
+ case DOM0_DESTROYDOMAIN:
{
unsigned int dom = op.u.killdomain.domain;
int force = op.u.killdomain.force;
}
break;
+ case DOM0_GETDOMAININFO:
+ {
+ struct task_struct *p;
+ u_long flags;
+
+ p = idle0_task.next_task;
+ read_lock_irqsave (&tasklist_lock, flags);
+ do {
+ if ((!is_idle_task (p)) && (p -> domain >= op.u.getdominfo.domain)) {
+ break;
+ }
+ } while ((p = p -> next_task) != &idle0_task);
+
+ if (p == &idle0_task) {
+ ret = -ESRCH;
+ } else {
+ op.u.getdominfo.domain = p -> domain;
+ strcpy (op.u.getdominfo.name, p -> name);
+ op.u.getdominfo.processor = p -> processor;
+ op.u.getdominfo.has_cpu = p -> has_cpu;
+ op.u.getdominfo.state = p -> state;
+ op.u.getdominfo.hyp_events = p -> hyp_events;
+ op.u.getdominfo.mcu_advance = p -> mcu_advance;
+ op.u.getdominfo.pg_head = list_entry(p->pg_head.next,
+ struct pfn_info, list) - frame_table;
+ op.u.getdominfo.tot_pages = p -> tot_pages;
+ }
+ read_unlock_irqrestore (&tasklist_lock, flags);
+ copy_to_user(u_dom0_op, &op, sizeof(op));
+ break;
+ }
+
default:
ret = -ENOSYS;
return 0;
}
+void stop_domain(void)
+{
+ current -> state = TASK_SUSPENDED;
+ clear_bit(_HYP_EVENT_STOP, &(current->hyp_events));
+ schedule ();
+}
+
+long stop_other_domain(unsigned int dom)
+{
+ unsigned long cpu_mask;
+ struct task_struct *p;
+
+ p = find_domain_by_id (dom);
+ if ( p == NULL) return -ESRCH;
+
+ if ( p -> state != TASK_SUSPENDED )
+ {
+ cpu_mask = mark_hyp_event(p, _HYP_EVENT_STOP);
+ hyp_event_notify(cpu_mask);
+ }
+
+ return 0;
+}
unsigned int alloc_new_dom_mem(struct task_struct *p, unsigned int kbytes)
{
case TASK_UNINTERRUPTIBLE:
case TASK_WAIT:
case TASK_DYING:
+ case TASK_SUSPENDED:
default:
/* done if not running. Else, continue */
goto deschedule_done;
#ifndef __DOM0_OPS_H__
#define __DOM0_OPS_H__
-#define DOM0_NEWDOMAIN 0
-#define DOM0_KILLDOMAIN 1
-#define DOM0_GETMEMLIST 2
-#define DOM0_STARTDOM 4
-#define DOM0_BVTCTL 6
-#define DOM0_ADJUSTDOM 7
+#define DOM0_GETMEMLIST 2
+#define DOM0_BVTCTL 6
+#define DOM0_ADJUSTDOM 7
+#define DOM0_CREATEDOMAIN 8
+#define DOM0_DESTROYDOMAIN 9
+#define DOM0_STARTDOMAIN 10
+#define DOM0_STOPDOMAIN 11
+#define DOM0_GETDOMAININFO 12
+#define DOM0_BUILDDOMAIN 13
#define MAX_CMD_LEN 256
+#define MAX_DOMAIN_NAME 16
typedef struct dom0_newdomain_st
{
unsigned int memory_kb;
unsigned int num_vifs; // temporary
unsigned long pg_head; // return parameter
+ char name[MAX_DOMAIN_NAME];
} dom0_newdomain_t;
typedef struct dom0_killdomain_st
unsigned long warpu; /* unwarp time requirement */
} dom0_adjustdom_t;
+typedef struct dom0_getdominfo_st
+{
+ unsigned int domain; /* All returns except domain */
+ char name[MAX_DOMAIN_NAME];
+ int processor;
+ int has_cpu;
+ int state;
+ int hyp_events;
+ unsigned long mcu_advance;
+ unsigned long pg_head;
+ unsigned int tot_pages;
+} dom0_getdominfo_t;
+
+
typedef struct dom0_op_st
{
unsigned long cmd;
dom0_bvtctl_t bvtctl;
dom0_adjustdom_t adjustdom;
dom_meminfo_t meminfo;
- }
+ dom0_getdominfo_t getdominfo;
+ }
u;
} dom0_op_t;
#include <xeno/time.h>
#include <xeno/ac_timer.h>
+#define MAX_DOMAIN_NAME 16
+
extern unsigned long volatile jiffies;
extern rwlock_t tasklist_lock;
#define _HYP_EVENT_NEED_RESCHED 0
#define _HYP_EVENT_DIE 1
+#define _HYP_EVENT_STOP 2
#define PF_DONEFPUINIT 0x1 /* Has the FPU been initialised for this task? */
#define PF_USEDFPU 0x2 /* Has this task used the FPU since last save? */
0-0xFFFFFFFF for kernel-thread
*/
+ char name[MAX_DOMAIN_NAME];
+
/*
* active_mm stays for now. It's entangled in the tricky TLB flushing
* stuff which I haven't addressed yet. It stays until I'm man enough
extern void kill_domain(void);
extern void kill_domain_with_errmsg(const char *err);
extern long kill_other_domain(unsigned int dom, int force);
+extern void stop_domain(void);
+extern long stop_other_domain(unsigned int dom);
/* arch/process.c */
void new_thread(struct task_struct *p,
#include <linux/iobuf.h>
#include <linux/highmem.h>
#include <linux/pagemap.h>
+#include <linux/seq_file.h>
#include <asm/pgalloc.h>
#include <asm/pgtable.h>
#include "dom0_ops.h"
+#define TRUE 1
+#define FALSE 0
+
/* Private proc-file data structures. */
typedef struct proc_data {
unsigned int domain;
#define XENO_BASE "xeno"
#define DOM0_CMD_INTF "dom0_cmd"
#define DOM0_NEWDOM "new_dom_data"
+#define DOM_LIST_INTF "domains"
#define MAX_LEN 16
#define DOM_DIR "dom"
struct proc_dir_entry *xeno_base;
static struct proc_dir_entry *dom0_cmd_intf;
static struct proc_dir_entry *proc_ft;
+static struct proc_dir_entry *dom_list_intf;
unsigned long direct_mmap(unsigned long, unsigned long, pgprot_t, int, int);
int direct_unmap(unsigned long, unsigned long);
ret = HYPERVISOR_dom0_op(&op);
/* if new domain created, create proc entries */
- if(op.cmd == DOM0_NEWDOMAIN){
+ if(op.cmd == DOM0_CREATEDOMAIN) {
create_proc_dom_entries(ret);
params = (dom0_newdomain_t *)kmalloc(sizeof(dom0_newdomain_t),
}
+/***********************************************************************
+ *
+ * Implementation of /proc/xeno/domains
+ */
+
+static dom0_op_t proc_domains_op;
+static int proc_domains_finished;
+static rwlock_t proc_xeno_domains_lock = RW_LOCK_UNLOCKED;
+
+static void *xeno_domains_next(struct seq_file *s, void *v, loff_t *pos)
+{
+ int ret;
+
+ if (pos != NULL) { ++ (*pos); }
+ if (!proc_domains_finished) {
+ proc_domains_op.u.getdominfo.domain ++;
+ ret = HYPERVISOR_dom0_op(&proc_domains_op);
+ if (ret < 0) proc_domains_finished = TRUE;
+ }
+
+ return (proc_domains_finished) ? NULL : &proc_domains_op;
+}
+
+static void *xeno_domains_start(struct seq_file *s, loff_t *ppos)
+{
+ loff_t pos = *ppos;
+
+ write_lock (&proc_xeno_domains_lock);
+ proc_domains_op.cmd = DOM0_GETDOMAININFO;
+ proc_domains_op.u.getdominfo.domain = 0;
+ (void)HYPERVISOR_dom0_op(&proc_domains_op);
+ proc_domains_finished = FALSE;
+
+ while (pos > 0) {
+ pos --;
+ xeno_domains_next (s, NULL, NULL);
+ }
+
+ return (proc_domains_finished) ? NULL : &proc_domains_op;
+}
+
+static void xeno_domains_stop(struct seq_file *s, void *v)
+{
+ write_unlock (&proc_xeno_domains_lock);
+}
+
+static int xeno_domains_show(struct seq_file *s, void *v)
+{
+ dom0_op_t *di = v;
+
+ seq_printf (s,
+ "%8d %2d %1d %2d %8d %8ld %p %8d %s\n",
+ di -> u.getdominfo.domain,
+ di -> u.getdominfo.processor,
+ di -> u.getdominfo.has_cpu,
+ di -> u.getdominfo.state,
+ di -> u.getdominfo.hyp_events,
+ di -> u.getdominfo.mcu_advance,
+ di -> u.getdominfo.pg_head,
+ di -> u.getdominfo.tot_pages,
+ di -> u.getdominfo.name);
+
+ return 0;
+}
+
+struct seq_operations xeno_domains_op = {
+ .start = xeno_domains_start,
+ .next = xeno_domains_next,
+ .stop = xeno_domains_stop,
+ .show = xeno_domains_show,
+};
+
+static int xeno_domains_open(struct inode *inode, struct file *file)
+{
+ return seq_open(file, &xeno_domains_op);
+}
+
+static struct file_operations proc_xeno_domains_operations = {
+ open: xeno_domains_open,
+ read: seq_read,
+ llseek: seq_lseek,
+ release: seq_release,
+};
+
+/***********************************************************************/
+
+
+
static int __init init_module(void)
{
/* xeno proc root setup */
dom0_cmd_intf->write_proc = cmd_write_proc;
}
+ /* domain list interface */
+ dom_list_intf = create_proc_entry (DOM_LIST_INTF, 0400, xeno_base);
+ if ( dom_list_intf != NULL )
+ {
+ dom_list_intf -> owner = THIS_MODULE;
+ dom_list_intf -> nlink = 1;
+ dom_list_intf -> proc_fops = &proc_xeno_domains_operations;
+ }
+
/* set up /proc entries for dom 0 */
create_proc_dom_entries(0);
* MUST BE KEPT IN SYNC WITH tools/domain_builder/dom0_ops.h
*/
-#define DOM0_NEWDOMAIN 0
-#define DOM0_KILLDOMAIN 1
-#define DOM0_GETMEMLIST 2
-#define DOM0_STARTDOM 4
-#define DOM0_BVTCTL 6
-#define DOM0_ADJUSTDOM 7
-#define MAP_DOM_MEM 8 /* Not passed down to Xen */
-#define DO_PGUPDATES 9 /* Not passed down to Xen */
-#define MAX_CMD 10
+#define DOM0_GETMEMLIST 2
+#define DOM0_BVTCTL 6
+#define DOM0_ADJUSTDOM 7
+#define DOM0_CREATEDOMAIN 8
+#define DOM0_DESTROYDOMAIN 9
+#define DOM0_STARTDOMAIN 10
+#define DOM0_STOPDOMAIN 11
+#define DOM0_GETDOMAININFO 12
+#define DOM0_BUILDDOMAIN 13
+#define MAP_DOM_MEM 14 /* Not passed down to Xen */
+#define DO_PGUPDATES 15 /* Not passed down to Xen */
+#define MAX_CMD 16
#define MAX_CMD_LEN 256
+#define MAX_DOMAIN_NAME 16
typedef struct dom0_newdomain_st
{
unsigned int memory_kb;
unsigned int num_vifs; /* temporary */
unsigned long pg_head; /* return parameter */
+ char name[MAX_DOMAIN_NAME];
} dom0_newdomain_t;
typedef struct dom0_killdomain_st
} dom_meminfo_t;
+typedef struct dom0_getdominfo_st
+{
+ unsigned int domain; /* All returns except domain */
+ char name[MAX_DOMAIN_NAME];
+ int processor;
+ int has_cpu;
+ int state;
+ int hyp_events;
+ unsigned long mcu_advance;
+ unsigned long pg_head;
+ unsigned int tot_pages;
+} dom0_getdominfo_t;
+
typedef struct dom0_op_st
{
dom_mem_t dommem;
dom_pgupdate_t pgupdate;
dom_meminfo_t meminfo;
- }
+ dom0_getdominfo_t getdominfo;
+ }
u;
} dom0_op_t;
projects / xen.git / commitdiff